package com.gongpingjialoan.utility;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.text.DecimalFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 描述：字符串处理类.
 * @author zr
 */
public final class AbStrUtil
{
    
    /**
     * 描述：将null转化为“”.
     * 
     * @param str 指定的字符串
     * @return 字符串的String类型
     */
    public static String parseEmpty(String str)
    {
        if (str == null || "null".equals(str.trim()))
        {
            str = "";
        }
        return str.trim();
    }
    
    /**
     * 描述：判断一个字符串是否为null或空值.
     * 
     * @param str 指定的字符串
     * @return true or false
     */
    public static boolean isEmpty(String str)
    {
        return str == null || str.trim().length() == 0 || str.equals("null");
    }
    
    /**
     * 获取字符串中文字符的长度（每个中文算2个字符）.
     * 
     * @param str 指定的字符串
     * @return 中文字符的长度
     */
    public static int chineseLength(String str)
    {
        int valueLength = 0;
        String chinese = "[\u0391-\uFFE5]";
        /* 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1 */
        if (!isEmpty(str))
        {
            for (int i = 0; i < str.length(); i++)
            {
                /* 获取一个字符 */
                String temp = str.substring(i, i + 1);
                /* 判断是否为中文字符 */
                if (temp.matches(chinese))
                {
                    valueLength += 2;
                }
            }
        }
        return valueLength;
    }
    
    /**
     * 描述：获取字符串的长度.
     * 
     * @param str 指定的字符串
     * @return 字符串的长度（中文字符计2个）
     */
    public static int strLength(String str)
    {
        int valueLength = 0;
        String chinese = "[\u0391-\uFFE5]";
        if (!isEmpty(str))
        {
            // 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1
            for (int i = 0; i < str.length(); i++)
            {
                // 获取一个字符
                String temp = str.substring(i, i + 1);
                // 判断是否为中文字符
                if (temp.matches(chinese))
                {
                    // 中文字符长度为2
                    valueLength += 2;
                }
                else
                {
                    // 其他字符长度为1
                    valueLength += 1;
                }
            }
        }
        return valueLength;
    }
    
    /**
     * 描述：获取指定长度的字符所在位置.
     * 
     * @param str 指定的字符串
     * @param maxL 要取到的长度（字符长度，中文字符计2个）
     * @return 字符的所在位置
     */
    public static int subStringLength(String str, int maxL)
    {
        int currentIndex = 0;
        int valueLength = 0;
        String chinese = "[\u0391-\uFFE5]";
        // 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1
        for (int i = 0; i < str.length(); i++)
        {
            // 获取一个字符
            String temp = str.substring(i, i + 1);
            // 判断是否为中文字符
            if (temp.matches(chinese))
            {
                // 中文字符长度为2
                valueLength += 2;
            }
            else
            {
                // 其他字符长度为1
                valueLength += 1;
            }
            if (valueLength >= maxL)
            {
                currentIndex = i;
                break;
            }
        }
        return currentIndex;
    }
    
    /**
     * 描述：手机号格式验证.
     * 
     * @param str 指定的手机号码字符串
     * @return 是否为手机号码格式:是为true，否则false
     */
    public static Boolean isMobileNo(String str)
    {
        Boolean isMobileNo = false;
        try
        {
            Pattern p = Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$");
            Matcher m = p.matcher(str);
            isMobileNo = m.matches();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return isMobileNo;
    }
    
    /**
     * 描述：是否只是字母和数字.
     * 
     * @param str 指定的字符串
     * @return 是否只是字母和数字:是为true，否则false
     */
    public static Boolean isNumberLetter(String str)
    {
        Boolean isNoLetter = false;
        String expr = "^[A-Za-z0-9]+$";
        if (str.matches(expr))
        {
            isNoLetter = true;
        }
        return isNoLetter;
    }
    
    /**
     * 描述：是否只是字母.
     * 
     * @param str 指定的字符串
     * @return 是否只是字母和数字:是为true，否则false
     */
    public static Boolean isLetter(String str)
    {
        Boolean isNoLetter = false;
        String expr = "^[A-Za-z]+$";
        if (str.matches(expr))
        {
            isNoLetter = true;
        }
        return isNoLetter;
    }
    
    /**
     * 描述：是否只是数字.
     * 
     * @param str 指定的字符串
     * @return 是否只是数字:是为true，否则false
     */
    public static Boolean isNumber(String str)
    {
        Boolean isNumber = false;
        String expr = "^[0-9]+$";
        if (str.matches(expr))
        {
            isNumber = true;
        }
        return isNumber;
    }
    
    /**
     * 描述：是否是邮箱.
     * 
     * @param str 指定的字符串
     * @return 是否是邮箱:是为true，否则false
     */
    public static Boolean isEmail(String str)
    {
        Boolean isEmail = false;
        String expr = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
        if (str.matches(expr))
        {
            isEmail = true;
        }
        return isEmail;
    }
    
    /**
     * 描述：是否是中文.
     * 
     * @param str 指定的字符串
     * @return 是否是中文:是为true，否则false
     */
    public static Boolean isChinese(String str)
    {
        Boolean isChinese = true;
        String chinese = "[\u0391-\uFFE5]";
        if (!isEmpty(str))
        {
            // 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1
            for (int i = 0; i < str.length(); i++)
            {
                // 获取一个字符
                String temp = str.substring(i, i + 1);
                // 判断是否为中文字符
                if (temp.matches(chinese))
                {
                }
                else
                {
                    isChinese = false;
                }
            }
        }
        return isChinese;
    }
    
    /**
     * 描述：是否包含中文.
     * 
     * @param str 指定的字符串
     * @return 是否包含中文:是为true，否则false
     */
    public static Boolean isContainChinese(String str)
    {
        Boolean isChinese = false;
        String chinese = "[\u0391-\uFFE5]";
        if (!isEmpty(str))
        {
            // 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1
            for (int i = 0; i < str.length(); i++)
            {
                // 获取一个字符
                String temp = str.substring(i, i + 1);
                // 判断是否为中文字符
                if (temp.matches(chinese))
                {
                    isChinese = true;
                }
                else
                {
                    
                }
            }
        }
        return isChinese;
    }
    
    /**
     * 描述：从输入流中获得String.
     * 
     * @param is 输入流
     * @return 获得的String
     */
    public static String convertStreamToString(InputStream is)
    {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder sb = new StringBuilder();
        String line = null;
        try
        {
            while ((line = reader.readLine()) != null)
            {
                sb.append(line + "\n");
            }
            
            // 最后一个\n删除
            if (sb.indexOf("\n") != -1 && sb.lastIndexOf("\n") == sb.length() - 1)
            {
                sb.delete(sb.lastIndexOf("\n"), sb.lastIndexOf("\n") + 1);
            }
            
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                is.close();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }
    
    /**
     * 描述：标准化日期时间类型的数据，不足两位的补0.
     * 
     * @param dateTime 预格式的时间字符串，如:2012-3-2 12:2:20
     * @return String 格式化好的时间字符串，如:2012-03-20 12:02:20
     */
    public static String dateTimeFormat(String dateTime)
    {
        StringBuilder sb = new StringBuilder();
        try
        {
            if (isEmpty(dateTime))
            {
                return null;
            }
            String[] dateAndTime = dateTime.split(" ");
            if (dateAndTime.length > 0)
            {
                for (String str : dateAndTime)
                {
                    if (str.indexOf("-") != -1)
                    {
                        String[] date = str.split("-");
                        for (int i = 0; i < date.length; i++)
                        {
                            String str1 = date[i];
                            sb.append(strFormat2(str1));
                            if (i < date.length - 1)
                            {
                                sb.append("-");
                            }
                        }
                    }
                    else if (str.indexOf(":") != -1)
                    {
                        sb.append(" ");
                        String[] date = str.split(":");
                        for (int i = 0; i < date.length; i++)
                        {
                            String str1 = date[i];
                            sb.append(strFormat2(str1));
                            if (i < date.length - 1)
                            {
                                sb.append(":");
                            }
                        }
                    }
                }
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
        return sb.toString();
    }
    
    /**
     * 描述：不足2个字符的在前面补“0”.
     * 
     * @param str 指定的字符串
     * @return 至少2个字符的字符串
     */
    public static String strFormat2(String str)
    {
        try
        {
            if (str.length() <= 1)
            {
                str = "0" + str;
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return str;
    }
    
    /**
     * 描述：截取字符串到指定字节长度.
     * 
     * @param str the str
     * @param length 指定字节长度
     * @return 截取后的字符串
     */
    public static String cutString(String str, int length)
    {
        return cutString(str, length, "");
    }
    
    /**
     * 描述：截取字符串到指定字节长度.
     * 
     * @param str 文本
     * @param length 字节长度
     * @param dot 省略符号
     * @return 截取后的字符串
     */
    public static String cutString(String str, int length, String dot)
    {
        int strBLen = strlen(str, "GBK");
        if (strBLen <= length)
        {
            return str;
        }
        int temp = 0;
        StringBuffer sb = new StringBuffer(length);
        char[] ch = str.toCharArray();
        for (char c : ch)
        {
            sb.append(c);
            if (c > 256)
            {
                temp += 2;
            }
            else
            {
                temp += 1;
            }
            if (temp >= length)
            {
                if (dot != null)
                {
                    sb.append(dot);
                }
                break;
            }
        }
        return sb.toString();
    }
    
    /**
     * 描述：截取字符串从第一个指定字符.
     * 
     * @param str1 原文本
     * @param str2 指定字符
     * @param offset 偏移的索引
     * @return 截取后的字符串
     */
    public static String cutStringFromChar(String str1, String str2, int offset)
    {
        if (isEmpty(str1))
        {
            return "";
        }
        int start = str1.indexOf(str2);
        if (start != -1)
        {
            if (str1.length() > start + offset)
            {
                return str1.substring(start + offset);
            }
        }
        return "";
    }
    
    /**
     * 描述：获取字节长度.
     * 
     * @param str 文本
     * @param charset 字符集（GBK）
     * @return the int
     */
    public static int strlen(String str, String charset)
    {
        if (str == null || str.length() == 0)
        {
            return 0;
        }
        int length = 0;
        try
        {
            length = str.getBytes(charset).length;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return length;
    }
    
    /**
     * 获取大小的描述.
     * 
     * @param size 字节个数
     * @return 大小的描述
     */
    public static String getSizeDesc(long size)
    {
        String suffix = "B";
        if (size >= 1024)
        {
            suffix = "K";
            size = size >> 10;
            if (size >= 1024)
            {
                suffix = "M";
                // size /= 1024;
                size = size >> 10;
                if (size >= 1024)
                {
                    suffix = "G";
                    size = size >> 10;
                    // size /= 1024;
                }
            }
        }
        return size + suffix;
    }
    
    /**
     * 描述：ip地址转换为10进制数.
     * 
     * @param ip the ip
     * @return the long
     */
    public static long ip2int(String ip)
    {
        ip = ip.replace(".", ",");
        String[] items = ip.split(",");
        return Long.valueOf(items[0]) << 24 | Long.valueOf(items[1]) << 16 | Long.valueOf(items[2]) << 8
            | Long.valueOf(items[3]);
    }
    
    /**
     * The main method.
     * 
     * @param args the arguments
     */
    public static void main(String[] args)
    {
        System.out.println(dateTimeFormat("2012-3-2 12:2:20"));
    }
    
    /**
     * 
     * 手机号码按344显示
     * 
     * @param phone
     * @return 最后更新时间：<date> 修改履历：<修改内容>
     */
    public static String sectionShow(String phone)
    {
        
        String str1 = phone.substring(0, 3);
        String str2 = phone.substring(3, 7);
        String str3 = phone.substring(7, 11);
        
        return str1 + " " + str2 + " " + str3;
    }


    //保留2位小数
    public static double get2Double(double a){
        DecimalFormat df=new DecimalFormat("0.00");
        return new Double(df.format(a).toString());
    }

    public static String getNumString(int num) {
        DecimalFormat df = new DecimalFormat("#,###");
        return df.format(num);
    }

}
